home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / hummer.swf / scripts / __Packages / math / Vector.as < prev   
Encoding:
Text File  |  2007-01-08  |  15.2 KB  |  502 lines
  1. var ┬º\x01┬º = 573;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 573)
  6.    {
  7.       set("\x01",eval("\x01") - 415);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 988)
  12.    {
  13.       set("\x01",eval("\x01") - 239);
  14.       ┬º┬ºpush(true);
  15.       continue;
  16.    }
  17.    if(eval("\x01") == 19)
  18.    {
  19.       set("\x01",eval("\x01") + 827);
  20.       if(┬º┬ºpop())
  21.       {
  22.          set("\x01",eval("\x01") - 30);
  23.       }
  24.       continue;
  25.    }
  26.    if(eval("\x01") == 281)
  27.    {
  28.       set("\x01",eval("\x01") + 15);
  29.       break;
  30.    }
  31.    if(eval("\x01") == 187)
  32.    {
  33.       set("\x01",eval("\x01") - 168);
  34.       ┬º┬ºpush(true);
  35.       continue;
  36.    }
  37.    if(eval("\x01") == 832)
  38.    {
  39.       set("\x01",eval("\x01") - 127);
  40.       ┬º┬ºpush(true);
  41.       continue;
  42.    }
  43.    if(eval("\x01") == 160)
  44.    {
  45.       set("\x01",eval("\x01") + 540);
  46.       break;
  47.    }
  48.    if(eval("\x01") == 265)
  49.    {
  50.       set("\x01",eval("\x01") + 74);
  51.       break;
  52.    }
  53.    if(eval("\x01") == 700)
  54.    {
  55.       set("\x01",eval("\x01") - 629);
  56.       ┬º┬ºpush(true);
  57.       continue;
  58.    }
  59.    if(eval("\x01") == 917)
  60.    {
  61.       set("\x01",eval("\x01") - 730);
  62.       nextFrame();
  63.       toggleHighQuality();
  64.       set(┬º┬ºpop(),┬º┬ºpop() >>> ┬º┬ºpop());
  65.       return ┬º┬ºpop()[┬º┬ºpop()]();
  66.    }
  67.    if(eval("\x01") == 71)
  68.    {
  69.       set("\x01",eval("\x01") + 210);
  70.       if(┬º┬ºpop())
  71.       {
  72.          set("\x01",eval("\x01") + 15);
  73.       }
  74.       continue;
  75.    }
  76.    if(eval("\x01") == 726)
  77.    {
  78.       set("\x01",eval("\x01") + 262);
  79.       break;
  80.    }
  81.    if(eval("\x01") == 705)
  82.    {
  83.       set("\x01",eval("\x01") - 545);
  84.       if(┬º┬ºpop())
  85.       {
  86.          set("\x01",eval("\x01") + 540);
  87.       }
  88.       continue;
  89.    }
  90.    if(eval("\x01") == 237)
  91.    {
  92.       set("\x01",eval("\x01") + 4);
  93.       break;
  94.    }
  95.    if(eval("\x01") == 296)
  96.    {
  97.       set("\x01",eval("\x01") + 138);
  98.       ┬º┬ºpush(true);
  99.       continue;
  100.    }
  101.    if(eval("\x01") == 755)
  102.    {
  103.       set("\x01",eval("\x01") + 162);
  104.       if(┬º┬ºpop())
  105.       {
  106.          set("\x01",eval("\x01") - 730);
  107.       }
  108.       continue;
  109.    }
  110.    if(eval("\x01") == 681)
  111.    {
  112.       set("\x01",eval("\x01") - 341);
  113.       if(┬º┬ºpop())
  114.       {
  115.          set("\x01",eval("\x01") - 307);
  116.       }
  117.       continue;
  118.    }
  119.    if(eval("\x01") == 339)
  120.    {
  121.       set("\x01",eval("\x01") + 342);
  122.       ┬º┬ºpush(true);
  123.       continue;
  124.    }
  125.    if(eval("\x01") == 158)
  126.    {
  127.       set("\x01",eval("\x01") + 79);
  128.       if(┬º┬ºpop())
  129.       {
  130.          set("\x01",eval("\x01") + 4);
  131.       }
  132.       continue;
  133.    }
  134.    if(eval("\x01") == 1)
  135.    {
  136.       set("\x01",eval("\x01") + 831);
  137.       ┬º┬ºpush(delete ┬º┬ºpop());
  138.       break;
  139.    }
  140.    if(eval("\x01") == 434)
  141.    {
  142.       set("\x01",eval("\x01") + 440);
  143.       if(┬º┬ºpop())
  144.       {
  145.          set("\x01",eval("\x01") - 597);
  146.       }
  147.       continue;
  148.    }
  149.    if(eval("\x01") != 846)
  150.    {
  151.       if(eval("\x01") == 816)
  152.       {
  153.          set("\x01",eval("\x01") - 142);
  154.          ┬º┬ºpush(true);
  155.       }
  156.       else if(eval("\x01") == 674)
  157.       {
  158.          set("\x01",eval("\x01") - 409);
  159.          if(┬º┬ºpop())
  160.          {
  161.             set("\x01",eval("\x01") + 74);
  162.          }
  163.       }
  164.       else
  165.       {
  166.          if(eval("\x01") == 874)
  167.          {
  168.             set("\x01",eval("\x01") - 597);
  169.             return new ┬º┬ºpop()[┬º┬ºconstant(3)]();
  170.          }
  171.          if(eval("\x01") == 241)
  172.          {
  173.             set("\x01",eval("\x01") + 475);
  174.             ┬º┬ºpush(true);
  175.          }
  176.          else if(eval("\x01") == 749)
  177.          {
  178.             set("\x01",eval("\x01") - 748);
  179.             if(┬º┬ºpop())
  180.             {
  181.                set("\x01",eval("\x01") + 831);
  182.             }
  183.          }
  184.          else if(eval("\x01") == 716)
  185.          {
  186.             set("\x01",eval("\x01") + 10);
  187.             if(┬º┬ºpop())
  188.             {
  189.                set("\x01",eval("\x01") + 262);
  190.             }
  191.          }
  192.          else
  193.          {
  194.             if(eval("\x01") != 277)
  195.             {
  196.                if(eval("\x01") == 340)
  197.                {
  198.                   set("\x01",eval("\x01") - 307);
  199.                   prevFrame();
  200.                   break;
  201.                }
  202.                if(eval("\x01") == 33)
  203.                {
  204.                   set("\x01",eval("\x01") + 46);
  205.                   if(!_global.math)
  206.                   {
  207.                      _global.math = new Object();
  208.                   }
  209.                   ┬º┬ºpop();
  210.                   if(!_global.math.Vector)
  211.                   {
  212.                      var _loc2_ = math.Vector = function(x, y)
  213.                      {
  214.                         this.initialize(x,y);
  215.                      }.prototype;
  216.                      _loc2_.initialize = function(x, y)
  217.                      {
  218.                         this.x = x;
  219.                         this.y = y;
  220.                      };
  221.                      _loc2_.toString = function()
  222.                      {
  223.                         var _loc3_ = Math.round(this.x * 1000) / 1000;
  224.                         var _loc2_ = Math.round(this.y * 1000) / 1000;
  225.                         return "[" + _loc3_ + ", " + _loc2_ + "]";
  226.                      };
  227.                      _loc2_.reset = function(x, y)
  228.                      {
  229.                         this.initialize(x,y);
  230.                      };
  231.                      _loc2_.getClone = function()
  232.                      {
  233.                         return new math.Vector(this.x,this.y);
  234.                      };
  235.                      _loc2_.equals = function(v)
  236.                      {
  237.                         return this.x == v.x && this.y == v.y;
  238.                      };
  239.                      _loc2_.plus = function(v)
  240.                      {
  241.                         this.x += v.x;
  242.                         this.y += v.y;
  243.                      };
  244.                      _loc2_.plusNew = function(v)
  245.                      {
  246.                         return new math.Vector(this.x + v.x,this.y + v.y);
  247.                      };
  248.                      _loc2_.minus = function(v)
  249.                      {
  250.                         this.x -= v.x;
  251.                         this.y -= v.y;
  252.                      };
  253.                      _loc2_.minusNew = function(v)
  254.                      {
  255.                         return new math[┬º┬ºconstant(3)](this.x - v.x,this.y - v.y);
  256.                      };
  257.                      _loc2_.negate = function()
  258.                      {
  259.                         this.x = - this.x;
  260.                         this.y = - this.y;
  261.                      };
  262.                      _loc2_.negateNew = function()
  263.                      {
  264.                         return new math.Vector(- this.x,- this.y);
  265.                      };
  266.                      _loc2_.scale = function(s)
  267.                      {
  268.                         this.x *= s;
  269.                         this.y *= s;
  270.                      };
  271.                      _loc2_.scaleNew = function(s)
  272.                      {
  273.                         return new math.Vector(this.x * s,this.y * s);
  274.                      };
  275.                      _loc2_.getLength = function()
  276.                      {
  277.                         return Math.sqrt(this.x * this.x + this.y * this.y);
  278.                      };
  279.                      _loc2_.setLength = function(len)
  280.                      {
  281.                         var _loc2_ = this.getLength();
  282.                         !_loc2_ ? (this.x = len) : this.scale(len / _loc2_);
  283.                      };
  284.                      _loc2_.getAngle = function()
  285.                      {
  286.                         return math.Degree.atan2D(this.y,this.x);
  287.                      };
  288.                      _loc2_.setAngle = function(ang)
  289.                      {
  290.                         var _loc2_ = this.getLength();
  291.                         this.x = _loc2_ * math.Degree.cosD(ang);
  292.                         this.y = _loc2_ * math.Degree.sinD(ang);
  293.                      };
  294.                      _loc2_.rotate = function(ang)
  295.                      {
  296.                         var _loc3_ = math.Degree.cosD(ang);
  297.                         var _loc2_ = math.Degree.sinD(ang);
  298.                         var _loc5_ = this.x * _loc3_ - this.y * _loc2_;
  299.                         var _loc4_ = this.x * _loc2_ + this.y * _loc3_;
  300.                         this.x = _loc5_;
  301.                         this.y = _loc4_;
  302.                      };
  303.                      _loc2_.rotateNew = function(ang)
  304.                      {
  305.                         var _loc2_ = new math.Vector(this.x,this.y);
  306.                         _loc2_.rotate(ang);
  307.                         return _loc2_;
  308.                      };
  309.                      _loc2_.dot = function(v)
  310.                      {
  311.                         return this.x * v.x + this.y * v.y;
  312.                      };
  313.                      _loc2_.getNormal = function()
  314.                      {
  315.                         return new math.Vector(- this.y,this.x);
  316.                      };
  317.                      _loc2_.isPerpTo = function(v)
  318.                      {
  319.                         return this.dot(v) == 0;
  320.                      };
  321.                      _loc2_.isNormalTo = function(v)
  322.                      {
  323.                         return this.isPerpTo(v);
  324.                      };
  325.                      _loc2_.angleBetween = function(v)
  326.                      {
  327.                         var _loc3_ = this.dot(v);
  328.                         var _loc2_ = _loc3_ / (this.getLength() * v.getLength());
  329.                         return math.Degree.acosD(_loc2_);
  330.                      };
  331.                      _loc2_.__get__x = function()
  332.                      {
  333.                         return this.$x;
  334.                      };
  335.                      _loc2_.__set__x = function(x)
  336.                      {
  337.                         this.$x = x;
  338.                         return this.x;
  339.                      };
  340.                      _loc2_.__get__y = function()
  341.                      {
  342.                         return this.$y;
  343.                      };
  344.                      _loc2_.__set__y = function(y)
  345.                      {
  346.                         this.$y = y;
  347.                         return this.y;
  348.                      };
  349.                      _loc2_.__get__length = function()
  350.                      {
  351.                         return this.getLength();
  352.                      };
  353.                      _loc2_.__set__length = function(len)
  354.                      {
  355.                         this.setLength(len);
  356.                         return this.length;
  357.                      };
  358.                      _loc2_.__get__angle = function()
  359.                      {
  360.                         return this.getAngle();
  361.                      };
  362.                      _loc2_.__set__angle = function(ang)
  363.                      {
  364.                         this.setAngle(ang);
  365.                         return this.angle;
  366.                      };
  367.                      ┬º┬ºpush(_loc2_.addProperty("angle",_loc2_.__get__angle,_loc2_.__set__angle));
  368.                      ┬º┬ºpush(_loc2_.addProperty("length",_loc2_.__get__length,_loc2_.__set__length));
  369.                      ┬º┬ºpush(_loc2_.addProperty("x",_loc2_.__get__x,_loc2_.__set__x));
  370.                      ┬º┬ºpush(_loc2_.addProperty("y",_loc2_.__get__y,_loc2_.__set__y));
  371.                      ┬º┬ºpush(ASSetPropFlags(math.Vector.prototype,null,1));
  372.                   }
  373.                   ┬º┬ºpop();
  374.                }
  375.                break;
  376.             }
  377.             set("\x01",eval("\x01") + 478);
  378.             ┬º┬ºpush(true);
  379.          }
  380.       }
  381.       continue;
  382.    }
  383.    set("\x01",eval("\x01") - 30);
  384.    ┬º┬ºpush(┬º┬ºpop() ^ ┬º┬ºpop() lt ┬º┬ºpop());
  385.    while(true)
  386.    {
  387.       if(eval("\x01") == 710)
  388.       {
  389.          set("\x01",eval("\x01") - 196);
  390.          ┬º┬ºpush(true);
  391.       }
  392.       else
  393.       {
  394.          if(eval("\x01") != 514)
  395.          {
  396.             if(eval("\x01") == 904)
  397.             {
  398.                set("\x01",eval("\x01") - 313);
  399.                setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  400.                ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  401.                break loop0;
  402.             }
  403.             if(eval("\x01") == 591)
  404.             {
  405.                set("\x01",eval("\x01") - 66);
  406.                this._parent.stop();
  407.                bg._x = 0;
  408.                bg._y = 0;
  409.                this._x = 0;
  410.                this._y = 0;
  411.                bg._width = Stage.width;
  412.                bg._height = Stage.height;
  413.                bg.swapDepths(10);
  414.                _quality = "BEST";
  415.                intro._xscale = 100;
  416.                intro._yscale = 100;
  417.                intro.swapDepths(11);
  418.                intro._x = Math.round((Stage.width - intro._width) / 2);
  419.                intro._y = Math.round((Stage.height - intro._height) / 2);
  420.                loaded = function()
  421.                {
  422.                   this._parent.gotoAndStop(2);
  423.                };
  424.                gotoGamezhero = function()
  425.                {
  426.                   getUrl("http://www.gamezhero.com/?utm_campaign=hrc&utm_source=hrc&utm_medium=context_menu", "_blank");
  427.                };
  428.                gamezheroMenu = new ContextMenu();
  429.                gamezheroMenu.builtInItems.forward_back = false;
  430.                gamezheroMenu.builtInItems.loop = false;
  431.                gamezheroMenu.builtInItems.play = false;
  432.                gamezheroMenu.builtInItems.print = false;
  433.                gamezheroMenu.builtInItems.rewind = false;
  434.                gamezheroMenu.builtInItems.zoom = false;
  435.                gamezheroMenu.builtInItems.save = false;
  436.                gamezheroMenu.customItems.push(new ContextMenuItem("More Free Games - gamezhero.com",gotoGamezhero));
  437.                _root.menu = gamezheroMenu;
  438.             }
  439.             break loop0;
  440.          }
  441.          set("\x01",eval("\x01") + 390);
  442.          if(┬º┬ºpop())
  443.          {
  444.             set("\x01",eval("\x01") - 313);
  445.          }
  446.       }
  447.       while(true)
  448.       {
  449.          if(eval("\x01") == 255)
  450.          {
  451.             set("\x01",eval("\x01") + 175);
  452.             ┬º┬ºpush(true);
  453.          }
  454.          else if(eval("\x01") == 430)
  455.          {
  456.             set("\x01",eval("\x01") - 96);
  457.             if(┬º┬ºpop())
  458.             {
  459.                set("\x01",eval("\x01") - 260);
  460.             }
  461.          }
  462.          else
  463.          {
  464.             if(eval("\x01") == 334)
  465.             {
  466.                set("\x01",eval("\x01") - 260);
  467.                ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop() + 1);
  468.                break loop0;
  469.             }
  470.             if(eval("\x01") == 74)
  471.             {
  472.                set("\x01",eval("\x01") + 375);
  473.                ┬º┬ºpush(true);
  474.             }
  475.             else
  476.             {
  477.                if(eval("\x01") == 862)
  478.                {
  479.                   set("\x01",eval("\x01") - 152);
  480.                   eval(┬º┬ºpop() or ┬º┬ºpop()).height.forward_back();
  481.                   if(_loc1_["Math" + (_loc1_._y - 100)]._height != true)
  482.                   {
  483.                      delete _loc1_["Math" + (_loc1_._y - 100)].height;
  484.                      _loc1_["Math" + (_loc1_._y - 100)]._xscale();
  485.                   }
  486.                   return Math.height;
  487.                }
  488.                if(eval("\x01") != 449)
  489.                {
  490.                   break;
  491.                }
  492.                set("\x01",eval("\x01") + 413);
  493.                if(┬º┬ºpop())
  494.                {
  495.                   set("\x01",eval("\x01") - 152);
  496.                }
  497.             }
  498.          }
  499.       }
  500.    }
  501. }
  502.